home *** CD-ROM | disk | FTP | other *** search
/ ADA Programming Guide / ADA Programming Guide.iso / ada_gwu / chapp.h < prev    next >
C/C++ Source or Header  |  1996-01-30  |  7KB  |  280 lines
  1. /*
  2.  * Copyright (C) 1985-1992  New York University
  3.  * 
  4.  * This file is part of the Ada/Ed-C system.  See the Ada/Ed README file for
  5.  * warranty (none) and distribution info and also the GNU General Public
  6.  * License for more details.
  7.  
  8.  */
  9.  
  10. /* Only 12b used by adagen*/
  11. #ifndef GEN
  12.  
  13. /* 0a */
  14. void init_sem();
  15. int in_op_designators(char *);
  16.  
  17. /* 0b */
  18. void adasem(Node);
  19. void sem_list(Node);
  20.  
  21. /* 2 */
  22. void process_pragma(Node);
  23.  
  24. /* 3a */
  25.  
  26. void obj_decl(Node);
  27. void const_decl(Node);
  28. Symbol check_init(Node, Node);
  29. int is_deferred_constant(Node);
  30. void number_decl(Node);
  31. void type_decl(Node);
  32. Symbol find_type_name(Node);
  33. void check_delayed_type(Node, Symbol);
  34. void subtype_decl(Node);
  35. Symbol make_subtype(Node);
  36. int is_derived_subprogram(Symbol);
  37.  
  38. /* 3b */
  39. Tuple apply_range(Node);
  40. void array_typedef(Node);
  41. void new_array_type(Symbol, Node);
  42. void new_constrained_array(Symbol, Node);
  43. Symbol anonymous_array(Node);
  44. Symbol constrain_array(Symbol, Node);
  45. Symbol make_index(Node);
  46. void record_decl(Symbol, Node, Node);
  47. void process_discr(Symbol, Node);
  48. void discr_redecl(Symbol, Node);
  49. int same_expn(Node exp1, Node exp2);
  50. void conformance_error(Node);
  51. void comp_decl(Node);
  52. Symbol constrain_record(Symbol, Node);
  53. int check_discriminant(Node);
  54. void variant_decl(Node);
  55. void incomplete_decl(Node);
  56. void check_incomplete(Symbol);
  57. void declarative_part(Node);
  58. Symbol promote_subtype(Symbol);
  59. Tuple subtype_expr(Symbol);
  60. int is_character_type(Symbol);
  61. int is_discrete_type(Symbol);
  62. int is_numeric(Symbol);
  63. int is_incomplete_type(Symbol);
  64. int is_unconstrained(Symbol);
  65. Symbol base_type(Symbol);
  66. Symbol named_type(char *);
  67. Symbol anonymous_type();
  68. Symbol named_atom(char *);
  69. int is_static_expr(Node);
  70.  
  71. /* 4a */
  72. int in_type_classes(Symbol);
  73. void check_type_i(Node);
  74. void check_type_r(Node);
  75. void check_type_d(Node);
  76. void check_type_u(Node);
  77. void check_type(Symbol, Node);
  78. void apply_constraint(Node, Symbol);
  79. int in_priv_types(Symbol);
  80. void resolve1(Node);
  81. void resolv_attr(Node);
  82. void resolve2(Node, Symbol);
  83.  
  84. /* 4b */
  85. void result_types(Node);
  86. void disambiguate(Node, Symbol);
  87. void remove_conversions(Node);
  88. Tuple valid_arith_types(Symbol, Tuple);
  89. Symbol intersect_types(Symbol t1, Symbol t2);
  90. void complete_op_expr(Node, Symbol);
  91. void specialize(Node, Symbol);
  92. void complete_arg_list(Tuple, Node);
  93.  
  94. /* 4c */
  95. int can_constrain(Symbol);
  96. Set valid_array_expn(Node);
  97. Symbol complete_array_expn(Node, Symbol);
  98. void valid_selected_expn(Node);
  99. Symbol complete_selected_expn(Node, Symbol);
  100. void complete_aggregate(Symbol, Node);
  101. void complete_string_literal(Node, Symbol);
  102. void complete_r_aggregate(Symbol, Node);
  103. Tuple build_comp_names(Node);
  104. void valid_task_name(Node);
  105. void complete_task_name(Node task1, Symbol);
  106. void res2_check(Node expn2, Symbol);
  107. Symbol attribute_type(int, Symbol, Node arg1, Node arg2);
  108. int compatible_types(Symbol, Symbol);
  109. void type_error(Set, Symbol, int, Node);
  110. void premature_access(Symbol, Node);
  111. void pass1_error(char *msg1, char *, Node);
  112. char *full_type_name(Symbol);
  113. int is_type_node(Node);
  114.  
  115. /* 5 */
  116. Symbol slice_type(Node,int);
  117. Symbol get_type(Node);
  118. void assign_statement(Node);
  119. int is_variable(Node);
  120. void statement_list(Node);
  121. void if_statement(Node);
  122. void case_statement(Node);
  123. void process_case(Symbol, Node);
  124. int is_static_subtype(Symbol);
  125. void new_block(Node);
  126. void loop_statement(Node);
  127. Symbol iter_var(Node);
  128. void exit_statement(Node);
  129. void return_statement(Node);
  130. void label_decl(Node);
  131. void lab_init();
  132. void lab_end();
  133. void goto_statement(Node);
  134.  
  135. /* 6 */
  136. void subprog_decl(Node);
  137. void check_spec(Node);
  138. void check_new_op(Node, Tuple, Symbol);
  139. Tuple get_formals(Node, char *);
  140. void subprog_body(Node);
  141. void process_subprog_body(Node, Symbol);
  142. Node new_not_equals(Symbol, Symbol);
  143. Tuple process_formals(Symbol, Tuple,int);
  144. void reprocess_formals(Symbol, Node);
  145. void normalize(Symbol, Node);
  146. int conform(Node exp1, Node exp2);
  147. void call_statement(Node);
  148. Symbol chain_overloads(char *, int, Symbol, Tuple, Symbol, Node);
  149. int can_overload(Symbol);
  150. int same_signature(Symbol sub1, Symbol sub2);
  151. int same_sig_spec(Symbol, Tuple);
  152. int same_type(Symbol type1, Symbol type2);
  153.  
  154. /* 7 */
  155. void package_specification(Node);
  156. void new_package(Node, int);
  157. void package_declarations(Node, Node);
  158. void module_body_id(int, Node);
  159. void module_body(int, Node);
  160. void private_decl(Node);
  161. void check_fully_declared(Symbol);
  162. void check_fully_declared2(Symbol);
  163. int is_private(Symbol);
  164. int is_limited_type(Symbol);
  165. void check_out_parameters(Tuple);
  166. int in_private_part(Symbol);
  167. int private_kind(Symbol);
  168. int is_fully_private(Symbol);
  169. void check_priv_decl(int, Symbol);
  170. Symbol private_ancestor(Symbol);
  171. void end_specs(Symbol);
  172. void check_incomplete_decls(Symbol, Node);
  173. Symbol get_specs(char *);
  174.  
  175. /* 8 */
  176. void find_old(Node);
  177. Symbol find_type(Node);
  178. void check_old(Node);
  179. Set find_agg_types();
  180. Set find_access_types();
  181. Symbol find_new(char *);
  182. void check_void(char *);
  183. void new_agg_or_access_acc(Symbol);
  184. void new_agg_or_access_agg(Symbol);
  185. char *original_name(Symbol);
  186. void rename_ex(Node);
  187. void rename_pack(Node);
  188. void rename_subprogram(Node);
  189. Tuple find_renamed_entity(int, Tuple, Symbol, Node);
  190. void rename_object(Node);
  191. void newscope(Symbol);
  192. void popscope();
  193. void newmod(char *);
  194. void use_clause(Node);
  195.  
  196. /* 9 */
  197. void task_spec(Node);
  198. void accept_statement(Node);
  199. void entry_decl(Node);
  200. void entry_family_decl(Node);
  201. void entry_call(Node);
  202. void check_entry_call(Node);
  203. void find_entry_name(Node);
  204. void terminate_statement(Node);
  205. void abort_statement(Node);
  206.  
  207. /* 10 */
  208. void new_compunit(char *, Node);
  209. void compunit(Node);
  210. #ifdef SAVE_TRACE
  211. void save_trace(char *, int, Node);
  212. #endif
  213. void save_trace_init();
  214. Tuple unit_symbtab(Symbol, char);
  215. void save_subprog_info(Symbol);
  216. void save_spec_info(Symbol, Tuple);
  217. void save_body_info(Symbol);
  218. void stub_head(int, Node);
  219. void save_stub(Node);
  220.  
  221. /* 11 */
  222. void except_decl(Node);
  223. void exception_part(Node);
  224. void exception_handler(Node);
  225. void raise_statement(Node);
  226.  
  227. /* 12a */
  228. void generic_subprog_spec(Node);
  229. void generic_subprog_body(Symbol, Node);
  230. void generic_pack_spec(Node);
  231. void generic_obj_decl(Node);
  232. void generic_type_decl(Node);
  233. void generic_priv_decl(Node);
  234. void check_generic_usage(Symbol);
  235. void generic_subp_decl(Node);
  236. void subprog_instance(Node);
  237. void package_instance(Node);
  238.  
  239. #endif
  240. /* 12b */
  241. void instantiate_subprog_tree(Node, Symbolmap);
  242. void instantiate_pack_tree(Node, Symbolmap, Tuple);
  243. Tuple instantiate_symbtab(Symbol, Symbol, Symbolmap);
  244. void update_symbtab_nodes(Symbolmap, Tuple);
  245. Private_declarations update_private_decls(Symbol, Symbolmap);
  246. Node instantiate_tree(Node, Symbolmap);
  247. Symbol replace(Symbol, Symbolmap);
  248. Symbolmap symbolmap_new();
  249. Symbol symbolmap_get(Symbolmap, Symbol);
  250. void symbolmap_put(Symbolmap, Symbol, Symbol);
  251. Nodemap nodemap_new();
  252. #ifndef GEN
  253.  
  254. /* 12c */
  255. Tuple instantiate_generics(Tuple, Node);
  256. Tuple check_nat_type(Node);
  257. void desig_to_op(Node);
  258. int is_discriminant_dependent(Node);
  259. void linear(Symbol);
  260. Symbol anon_proc_instance(Symbol, Tuple, Symbol);
  261. void is_identifier();
  262. void is_tuple();
  263.  
  264. /* 13 */
  265. void length_clause(Node);
  266. void enum_rep_clause(Node);
  267. void rec_rep_clause(Node);
  268. void initialize_representation_info(Symbol, int);
  269. void choose_representation(Symbol);
  270. void inherit_representation_info(Symbol, Symbol);
  271. int     already_forced(Symbol);
  272. void not_chosen_put(Symbol, Symbol);
  273. Node size_attribute(Node);
  274. Node storage_size_attribute(Node);
  275. void force_representation(Symbol);
  276. void force_all_types();
  277. /* 14 */
  278. void check_range_attribute(Node);
  279. #endif
  280.